<template>
  <div>
    <BasicDrawer v-bind="$attrs" @register="registerDrawer" :showFooter="false" title="提交/查看排产计划" width="100%">
      <!--    表格区-->
      <div style="background: white">
        <div v-if="mainId" style="margin-left: 15px;padding-top: 10px">现处于查看模式mainId:{{mainId}}  <vxe-button size="small" style="margin-left: 15px"  status="error" content="删除该排产记录" :loading="saveLoading" @click="applyViewShow=true" v-if="mainId"></vxe-button></div>
        <!--    搜索区-->
        <vxe-form
          ref="formRef"
          :data="formData"
          size="small"
          @submit="submitEvent"
          @reset="resetEvent">

          <vxe-form-item title="日期区间" field="date_rang" span="5" :item-render="{}">
            <template #default="params">
              <RangePicker v-model:value="formData.date_rang" :disabled="dis_click_jiaban" value-format="YYYY-MM-DD"/>
            </template>
          </vxe-form-item>
          <vxe-form-item title="切线分钟数" field="qieNum" span="5"  :item-render="{defaultValue:formData.qieNum}">
            <template #default="params">
              <InputNumber v-model:value="formData.qieNum" :disabled="dis_click_jiaban"/>
            </template>
          </vxe-form-item>

          <vxe-form-item  span="4" :item-render="{}">
            <template #default>
              <vxe-button type="submit" status="primary" content="生成" :loading="loading" :disabled="dis_click_jiaban"></vxe-button>
              <!--            type="reset"-->
              <vxe-button  content="重置" :loading="loading" @click="resetEvent" v-if="!mainId"></vxe-button>
              <!--              <vxe-button  content="测试" :loading="loading" @click="testFn" v-if="!mainId"></vxe-button>-->

              <vxe-button  status="success" content="保存" :loading="saveLoading" @click="subFn" :disabled="!dis_click_jiaban" v-if="!mainId"></vxe-button>

            </template>
          </vxe-form-item>
        </vxe-form>

        <div v-for='(item,index) in planDateList' v-if="planDateList.length>0">




          <Divider>{{item.date}}</Divider>

          <div style="margin-left: 10px;display: flex">
            <div>
              <span>是否加班</span> <vxe-switch size="small" v-model="item.iz_jia_ban" @change="e=>switchJiaBan(e,item)" :disabled="item.no_select_jiaban"></vxe-switch>
            </div>
            <div v-if="item.sunday">
              <span style="margin-left: 20px">周日是否排班</span> <vxe-switch size="small" v-model="item.sun_do" @change="e=>switchSunday(e,item,index)" :disabled="item.no_select_jiaban"></vxe-switch>
            </div>
            <div v-if="item.arr1_shengyu_num" style="margin-left: 20px">
              <vxe-text :content="'1线超出'+item.arr1_shengyu_num+'未安排'" status="error"></vxe-text>
            </div>
            <div v-if="item.arr2_shengyu_num" style="margin-left: 20px">
              <vxe-text :content="'2线超出'+item.arr2_shengyu_num+'未安排'" status="error"></vxe-text>
            </div>
          </div>

          <div style="top: 10px;height:450px;display: flex;width: 100%;overflow-y: auto">

            <div class="my-table">
              <vxe-grid  v-bind="gridOptions" :data="item.left_arr"  class="my-table">
                <template #footer_100="{row,rowIndex}">
                  {{item.footData['100']}}
                </template>
                <template #footer_200_500="{row,rowIndex}">
                  {{item.footData['200_500']}}
                </template>
                <template #footer_step="{row,rowIndex}">
                  {{item.footData.step}}
                </template>
                <template #footer_K950="{row,rowIndex}">
                  {{item.footData.K950}}
                </template>
              </vxe-grid>
            </div>
            <div class="my-table">
              <vxe-grid  v-bind="gridOptions1" :data="item.arr1" class="my-table" >

                <template #orderNo_slot="{row,rowIndex}">
                  <SelectOrderIndex  @onSubmitFn="e=>orderSuccessFn(e,row,index,rowIndex,'arr1')" v-model:value="row.biaoShiHao"
                                     :selectOrderNo="selectOrderNo"
                                     v-if="!row.biaoShiHao&&!mainId" >

                  </SelectOrderIndex>
                  <div v-else>{{row.biaoShiHao}}</div>

                </template>
                <template #footer_num="{row,rowIndex}">
                  {{item.footData.arr1_total}}
                </template>
                <template #action="{ row ,rowIndex}">
                  <TableAction outside :actions="getActions(row,index,rowIndex,'arr1')" />
                </template>

              </vxe-grid>
            </div>
            <div class="my-table">
              <vxe-grid  v-bind="gridOptions2" :data="item.arr2" class="my-table" >

                <template #orderNo_slot="{row,rowIndex}">
                  <SelectOrderIndex  @onSubmitFn="e=>orderSuccessFn(e,row,index,rowIndex,'arr2')" v-model:value="row.biaoShiHao"
                                     :selectOrderNo="selectOrderNo"
                                     v-if="!row.biaoShiHao&&!mainId" ></SelectOrderIndex>
                  <div v-else>{{row.biaoShiHao}}</div>
                </template>
                <template #action="{ row,rowIndex }">
                  <TableAction outside :actions="getActions(row,index,rowIndex,'arr2')" />
                </template>
                <template #footer_num="{row,rowIndex}">
                  {{item.footData.arr2_total}}
                </template>
              </vxe-grid>
            </div>

          </div>


        </div>

        <SelectOrderIndex ref="qieXianRef"  @onSubmitFn="orderSuccessFn2"       :selectOrderNo="selectOrderNo" :isAdd="true"
        ></SelectOrderIndex>

      </div>
    </BasicDrawer>
    <Modal v-model:visible="applyViewShow" title="是否删除该排产记录？" @ok="removeMainPlanFn">
      <div>
        <p v-for="(item, index) in selectOrderNo">订单标识号:{{ item }} </p>
      </div>
    </Modal>
  </div>


</template>
<script lang="ts" setup>
import {
  BasicTableProps,
  VxeBasicTable,
  VxeGridInstance,
  VxeTableDefines,
} from '@/components/VxeTable';
import SelectOrderIndex from '@/views/dkn/components/formSelectTable/order/SelectOrderIndex.vue';
import { VxeUI } from 'vxe-pc-ui'

import { BasicTable, useTable, TableAction } from '@/components/Table';
import { BasicDrawer, useDrawerInner } from '@/components/Drawer';

import { useDrawer } from '@/components/Drawer';
import util from "@/utils/util";
import {onMounted, reactive, ref} from 'vue';
import dayjs from 'dayjs';
import { useMessage } from "@/hooks/web/useMessage";
import {RangePicker, Divider, InputNumber, Modal} from 'ant-design-vue';
import { useGo } from "@/hooks/web/usePage";
import {vxeTableColumns,baseColumns} from "./role.data";
import { router } from '@/router';

import {getMainPlan, productionPlanAdd, removeMainPlan} from '@/api/heng/dkn';

const go = useGo();

const saveLoading=ref(false);//保存

const qieXianRef=ref();//切线弹层

defineOptions({ name: 'ywDeptList' });
const { createMessage } = useMessage();
const emit = defineEmits(['success', 'register']);

// const [register, { openModal, closeModal }] = useModal();

const [registerDrawer, { setDrawerProps, closeDrawer }] = useDrawerInner(async (data) => {
  //打开弹层后的回调

  if(data?.mainId){
    mainId.value=data?.mainId;
    detailFn();
  }else{
    mainId.value=null;
    resetEvent();
  }

});


const gridOptions = reactive<BasicTableProps>({
  // keepSource: true,
  editConfig: { trigger: 'click', mode: 'cell', showStatus: true },
  border: true,
  showOverflow: true,
  size: 'mini',
  height: 'auto', // 'auto'
  columns: vxeTableColumns,
  filterConfig: {
    remote: true,
  },
  showFooter: true,
  footerData: [
    { from: '合计', num: 0 }
  ],
  toolbarConfig: {
    enabled: false,
  },
  formConfig: {
    enabled: false,
  },
  pagerConfig: {
    enabled: false,
  },
  proxyConfig: {
    enabled: false,
  },
});


let vxeTableColumns1= util.copy(baseColumns);
vxeTableColumns1[0].title="1线";
let vxeTableColumns2= util.copy(baseColumns);
vxeTableColumns2[0].title="2线";
// let vxeTableColumns3= util.copy(baseColumns);
// vxeTableColumns3[0].title="3线";
// let vxeTableColumns4= util.copy(baseColumns);
// vxeTableColumns4[0].title="4线";


let base_options=<BasicTableProps>{
  // keepSource: true,
  editConfig: { trigger: 'click', mode: 'cell', showStatus: true },
  border: true,
  showOverflow: true,
  size: 'mini',
  height: 'auto', // 'auto'
  columns: vxeTableColumns1,
  filterConfig: {
    remote: true,
  },
  showFooter: true,
  footerData: [
    { timeRank: '合计', num: 0 }
  ],
  toolbarConfig: {
    enabled: false,

  },
  // layouts:{[ ['Toolbar']]},
  formConfig: {
    enabled: false,
  },
  pagerConfig: {
    enabled: false,
  },
  proxyConfig: {
    enabled: false,
  },
};

let options1= util.copy(base_options);
options1.columns=vxeTableColumns1;
let options2= util.copy(base_options);
options2.columns=vxeTableColumns2;
// let options3= util.copy(base_options);
// options3.columns=vxeTableColumns3;
// let options4= util.copy(base_options);
// options4.columns=vxeTableColumns4;
const gridOptions1 = reactive<BasicTableProps>(options1);
const gridOptions2 = reactive<BasicTableProps>(options2);
// const gridOptions3 = reactive<BasicTableProps>(options3);
// const gridOptions4 = reactive<BasicTableProps>(options4);

//表格行数据类型规范
interface item_em{
  biaoShiHao:string,
  model:string,//型号
  guige:string,//规格 颜色
  thisNum:number, //本次排查量
  allType?:number,//allType 是否能够完全被分配 1 完全 0 有剩余时间可被分配其他 产品
  qieXian?:number,//1已切线
  num?:number,//计算排产的数量
}

//上一次 选择的切线 行，是从哪行开始切线的
interface qie_xian_em{
  data?:item_em,//上一行的数据
  p_index?:number,//最外层数组下班
  rowIndex?:number,//开始切线那行的下标
  arr_name?:string,//产线名称
}

const loading=ref(false);
const msgList = ref([]);
const mainId=ref("");//主记录id
const dataList2=ref([]);

const planDateList=ref([]);//计划日期区间
const selectOrderNo=ref([]);//已选单号
const dis_click_jiaban=ref(false);//加班按钮能否被点击

const qie_xian_obj=ref(<qie_xian_em>{});//选择切线的数据存储

const applyViewShow = ref(false);

const tableRef = ref<VxeGridInstance>();

const formData=ref({
  date_rang:[],
  qieNum:10,
});

function findPageList(page, form, filterList?: VxeTableDefines.FilterCheckedParams<any>[]) {
  let json = {};
  if (filterList && filterList.length) {
    filterList.forEach((e) => {
      const value = e.datas[0];
      let field = e.field;
      json[field + 'Like'] = value;
    });
  }
}



function initFn(){
  // createFn(['2025-09-20','2025-09-21'])

}

function detailFn(){
  getMainPlan({mainId:mainId.value}).then(res=>{
    if(res.code==200){
      let dataJson=JSON.parse(res.data.txtJson);
      // console.log("----dataJson.planDateList:",dataJson.planDateList)
      planDateList.value=dataJson.planDateList;
      formData.value=dataJson.formData;
      selectOrderNo.value=dataJson.selectOrderNo;
      dis_click_jiaban.value=true;
      // createMessage.success(res.message);
    }else{
      createMessage.error(res.message);
    }
  });
}

function removeMainPlanFn(){
  removeMainPlan({mainId:mainId.value}).then(res=>{
    if(res.code==200){
      createMessage.success(res.message);
      applyViewShow.value = false;
      closeDrawer();
      emit('success');
    }else{
      createMessage.error(res.message);
    }
  });
}

function submitEvent({data}) {
  //console.log("--submitEvent:",data);

  const start = data.date_rang[0];
  const end = data.date_rang[1];
  const dates = getAllDatesBetween( start, end);
  // console.log(`从${start}到${end}的所有日期：`);
  //console.log(dates);
  createFn(dates)

}
function resetEvent(e){
  qie_xian_obj.value={};
  dis_click_jiaban.value=false;
  selectOrderNo.value=[];
  planDateList.value=[];
  formData.value={
    date_rang:[],
    qieNum:10,
  };
  initFn();
}

function testFn(){
  let local_planDateList= util.copy(planDateList.value);
  console.log("---local_planDateList:",local_planDateList)
}

var d_arr=[
  {"from": "8:00", "to": "9:00", "duration": 60, "100": 450, "200_500": 360, "step": 280, "K950": 40,iz_zc_ban:true,},
  {"from": "9:00", "to": "10:00", "duration": 60, "100": 450, "200_500": 360, "step": 280, "K950": 40,iz_zc_ban:true},
  {"from": "10:10", "to": "11:00", "duration": 50, "100": 375, "200_500": 300, "step": 234, "K950": 34,iz_zc_ban:true},
  {"from": "11:00", "to": "11:50", "duration": 50, "100": 375, "200_500": 300, "step": 234, "K950": 34,iz_zc_ban:true},
  {"from": "13:10", "to": "14:00", "duration": 50, "100": 375, "200_500": 300, "step": 234, "K950": 34,iz_zc_ban:true},
  {"from": "14:00", "to": "15:00", "duration": 60, "100": 450, "200_500": 360, "step": 280, "K950": 40,iz_zc_ban:true},
  {"from": "15:00", "to": "15:30", "duration": 30, "100": 225, "200_500": 180, "step": 140, "K950": 20,iz_zc_ban:true},
  {"from": "15:40", "to": "16:00", "duration": 20, "100": 150, "200_500": 120, "step": 94, "K950": 14,iz_zc_ban:true},
  {"from": "16:00", "to": "17:00", "duration": 60, "100": 450, "200_500": 360, "step": 280, "K950": 40,iz_zc_ban:true},

  // {"from": "17:00", "to": "17:20", "duration": 20, "100": 150, "200_500": 120, "step": 93, "K950": 13,iz_zc_ban:true},
];

var d_arr_1={"from": "17:00", "to": "17:40", "duration": 40, "100": 300, "200_500": 240, "step": 187, "K950": 27,iz_zc_ban:true};
var d_arr_2={"from": "17:00", "to": "17:20", "duration": 20, "100": 150, "200_500": 120, "step": 93, "K950": 13,iz_zc_ban:true};

var d_arr2=[
  {"from": "18:10", "to": "19:00", "duration": 50, "100": 375, "200_500": 300, "step": 233, "K950": 33,iz_zc_ban:false},
  {"from": "19:00", "to": "20:00", "duration": 60, "100": 450, "200_500": 360, "step": 280, "K950": 40,iz_zc_ban:false},
  {"from": "20:00", "to": "20:30", "duration": 30, "100": 225, "200_500": 180, "step": 140, "K950": 20,iz_zc_ban:false}
]

function createFn(dates){



  let arr=[];
  dates.forEach(date => {
    let left_arr=[...d_arr,d_arr_1];
    let footData={
      "100": 0, "200_500": 0, "step": 0, "K950": 0,
      arr1_total:0,
      arr2_total:0
    };
    let json={
      date,
      iz_jia_ban:false,
      no_select_jiaban:false,//加班按钮是否可以点击
      footData,
      sunday: dayjs(date).day() === 0,//周日
      sun_do: false,
      left_arr,
      arr1:[],
      arr2:[]};
    countLeftArrFoot(json);
    // console.log("--统计尾部数据：",json)
    arr.push(json);
  });
  arr[0].arr1=[{izNull:1}];
  arr[0].arr2=[{izNull:1}];
  planDateList.value = arr;
}




/**
 * 获取从开始日期到结束日期之间的所有日期
 * @param {string|Date} startDate 开始日期
 * @param {string|Date} endDate 结束日期
 * @param {string} format 日期格式，默认'YYYY-MM-DD'
 * @returns {string[]} 包含所有日期的数组
 */
function getAllDatesBetween(startDate, endDate, format = 'YYYY-MM-DD') {
  // 转换为dayjs对象并设置为当天的起始时间
  let start = dayjs(startDate).startOf('day');
  let end = dayjs(endDate).startOf('day');

  // 验证日期有效性
  if (!start.isValid() || !end.isValid()) {
    throw new Error('无效的日期格式');
  }

  // 如果开始日期晚于结束日期，交换它们
  if (start.isAfter(end)) {
    [start, end] = [end, start];
  }

  const dates = [];
  let currentDate = start;

  // 循环添加所有日期直到超过结束日期（兼容旧版本dayjs）
  // 当currentDate在end之后时停止循环
  while (!currentDate.isAfter(end)) {
    dates.push(currentDate.format(format));
    currentDate = currentDate.add(1, 'day');
  }

  return dates;
}


function switchJiaBan(e,item){
  // console.log("---switchJiaBan:item:",item)
  if(e.value){
    item.left_arr=[...d_arr,d_arr_2,...d_arr2];
  }else{
    item.left_arr=[...d_arr,d_arr_1];
  }
  // let json={ "100": 0, "200_500": 0, "step": 0, "K950": 0};
  countLeftArrFoot(item);

}

//统计目标产能 尾部合计
function countLeftArrFoot(item){
  let n_100=0,n_200_500=0,step=0,K950=0;
  item.left_arr.forEach(item => {
    n_100+=item['100'];
    n_200_500+=item['200_500'];
    step+=item['step'];
    K950+=item['K950'];
  })
  item.footData['100']=n_100;
  item.footData['200_500']=n_200_500;
  item.footData['step']=step;
  item.footData['K950']=K950;
}

function switchSunday(e,item,index){
  // console.log("---switchSunday:item:",item);
  // console.log("---e:",e.value);
  // let local_planDateList= util.copy(planDateList.value);

  let last_index=null;//周日上一个有没有数据
  if(index-1!>=0){
    last_index=index-1;
  }

  if(e.value){

    if(last_index!=null){
      let last_p_item=planDateList.value[last_index];
      if(last_p_item.arr1.length>1){
        item.arr1=[{izNull:1}]
      }
      if(last_p_item.arr2.length>1){
        item.arr2=[{izNull:1}]
      }
    }else{

      item.arr1=[{izNull:1}]
      item.arr2=[{izNull:1}]
    }


  }else{
    if(item.arr1.length==1){
      item.arr1=[]
    }
    if(item.arr2.length==1){
      item.arr2=[]
    }
  }


  //周日下一个还有没有日期
  if(index<planDateList.value.length-1){
    let next_p_item=planDateList.value[index+1];
    if(e.value){
      if(next_p_item.arr1.length==1){
        next_p_item.arr1=[]
      }
      if(next_p_item.arr2.length==1){
        next_p_item.arr2=[]
      }
    }else{

      // 上一个
      if(last_index!=null){
        let last_p_item=planDateList.value[last_index];
        if(last_p_item.arr1.length>1){
          if(next_p_item.arr1.length==0){
            next_p_item.arr1=[{izNull:1}]
          }
          if(next_p_item.arr2.length>1){
            next_p_item.arr2=[{izNull:1}]
          }
        }
      }

    }
  }

}

//操作记录
const operator_arr=ref([]);

/**
 *
 * 第一行选择和某一行选择标识号
 * @param e1  选择的订单标识号的数据
 * @param e2  行数据
 * @param p_index 最外层的数组下标
 * @param rowIndex 日期所在数组的下标
 * @param arr_name 哪条线
 */
function orderSuccessFn(e1,e2,p_index,rowIndex,arr_name){

  let old_row=util.copy(e2);
  let modelJson =getCountModelJson();
  let pass=false;
  for (let key in modelJson) {
    //匹配型号 获取对应的产能
    if (e1.model.includes(key)) {
      pass=true;
    }
  }
  if(!pass){
    openAlert();
    return false;
  }

  //数据合并 第一行 或者是 选择标识号的那行（排产）
  for (let key in e1) {
    if(key!='_X_ROW_KEY'){
      e2[key]=e1[key];
    }
  }
  // console.log("---e2:thisNum:",e2.thisNum);

  //开始计算
  //     {"from": "20:00", "to": "20:30", "duration": 30, "100": 225, "200_500": 180, "step": 140, "K950": 20,iz_zc_ban:false}

  //最开始的流程
  if(rowIndex==0){
    let t={
      data:e2,
      p_index,
      rowIndex,
      arr_name
    }
    operator_arr.value[0]=t;
    /**
     * 初始化
     * 从第一行一直算到最后一行
     */
    handleArr(e2,old_row,p_index,rowIndex,arr_name,"选择")
  }else{
    // console.log("---切线 e1:",e1,"--e2:",e2)
    handleArr(e2,old_row,p_index,rowIndex,arr_name,"切线-选择")
  }
}

/**
 *
 * @param e2 x选择标识号弹层回来的数据
 * @param p_index
 * @param rowIndex
 * @param arr_name
 * action_name 切线，选择
 */

/**
 * 切线时 rowIndex有没有赋值给 i2 下标过，有赋值后就不在赋值
 * e2 是选择弹层的数据
 * e1 是上一行的数据
 * 场景：当出现 跨日期 但是生产数量还没被排产完，第二天的rowIndex 跟上一天的是一样的，如何解决？
 */
const index_2_set=ref(false);//

function handleArr(e2,e1,p_index,rowIndex,arr_name,action_name){
  dis_click_jiaban.value=true;

  let modelJson =getCountModelJson()
  selectOrderNo.value.push(e2.biaoShiHao);
  // console.log("-p_index.clone():",util.copy(p_index))
  // console.log("---e2.thisNum:",e2.thisNum);
  //  console.log("--rowIndex:",rowIndex);
  /**
   * 扣除切线时间
   */
  let iz_qie_cation=false;//判断是否切线的动作,选择 不是第一行的也是切线,大类型
  let iz_qie_cation_qie=false;//切线动作-切线
  let iz_qie_cation_select=false;//切线动作-请选择
  if(action_name=='切线'||action_name=='切线-选择'){
    iz_qie_cation=true;
    if(action_name=='切线'){
      iz_qie_cation_qie=true;
    }
    if(action_name=='切线-选择'){
      iz_qie_cation_select=true;
    }
  }
  // console.log("---iz_qie_cation:",iz_qie_cation)
  /**
   * 切线逻辑 26号
   * 1 判断加上切线10分钟会不会超出 当前 总时长：上一条的数量 所用了多少分钟+10分钟 是否大于 上一条总时长
   * 1-1 不会
   *      剩余分钟数=  总时长- 上一条的数量 所用了多少分钟 -10分钟
   *      剩余分钟数 是否大于 下一条的总时长，超出部分直接丢弃

   *        求当前能做多少个：剩余分钟数* 人均产能
   *  2-1 会 (切线分钟数会散落在上下两行)
   *       下行切线时间: 10分钟- 总时长- 上一条的数量 所用了多少分钟
   *       下行剩余产能: (下行总时间-下行切线时间)*下行人均产能
   *
   *
   *  切线 当天每次切线都要加10分钟,当天刚好做完,到第二天 刚开始的则不需要
   *  切线逻辑 27号: rowIndex 上一条下标
   *  1
   */
    // console.log("---my_now_index.e1=",e1);


    // console.log("==planDateList:",util.copy(planDateList.value))
  let local_planDateList= util.copy(planDateList.value);
  local_planDateList[p_index].no_select_jiaban=true;//加班不可选
  let left_arr=local_planDateList[p_index].left_arr;
  if(iz_qie_cation){
    let left_item2=left_arr[rowIndex];
    let t_count_num1=null;//目标产能
    let model=null;
    if(iz_qie_cation_select){
      model= e2.model
    }
    if(iz_qie_cation_qie){
      model= e1.model;//拿上一行的型号
    }
    for (let key in modelJson) {
      if(model.includes(key)){
        t_count_num1=left_item2[modelJson[key]];
        //--start
        /**
         * 1 判断加上切线10分钟会不会超出 总时长：上一条的数量（e1.num）  所用了多少分钟+10分钟 是否大于 上一条总时长
         */
          // 上一条的平均产能
        let last_pingjun=t_count_num1/left_item2.duration;//每分钟平均产能

        let last_num=e1.num;//上一条的数量
        if(iz_qie_cation_select){
          let thiz_p_item =local_planDateList[p_index];
          let thiz_arr =thiz_p_item[`${arr_name}`];
          last_num=thiz_arr[rowIndex-1]
        }
        // 上一条的数量（e1.num）  所用了多少分钟 +10分钟
        let last_time=last_num/last_pingjun;//上一条的数量 所用了多少分钟
        // console.log("----上一条所用时间:",last_time)
        let last_total=last_time+formData.value.qieNum;
        // 是否超出上条总时间
        if(last_total<=left_item2.duration){
          // 1-1 不会


          //  剩余分钟数=  总时长- 上一条的数量 所用了多少分钟 -10分钟
          let shengyu_shijian =left_item2.duration-last_total;
          //   剩余分钟数 是否大于 当前的总时长，超出部分直接丢弃
          let now_count_num1=null;//当前目标产能
          let model2=e2.model;

          for (let key in modelJson) {
            if(model2.includes(key)){
              now_count_num1=left_item2[modelJson[key]];
              //  剩余分钟数 是否大于 下一条的总时长，超出部分直接丢弃
              let now_pingjun=now_count_num1/left_item2.duration;
              // 求当前能做多少个：剩余时间* 当前人均产能
              let now_do_num=  shengyu_shijian*now_pingjun;
              left_item2[`${modelJson[key]}2`]= Math.round(now_do_num);
              left_item2.now_shengyu_shijian=shengyu_shijian;
              //  console.log("--left_item2.now_shengyu_shijian;")
              break;
            }
          };

        }else{
          // 2-1 会(切线分钟数会散落在上下两行)
          //下行切线时间: 10分钟- 总时长- 上一条的数量 所用了多少分钟
          let next_qie_shijian= formData.value.qieNum - (left_item2.duration- last_time);
          //下行剩余产能: (下行总时间-下行切线时间)*下行人均产能
          //先获取当前行
          let my_now_index=null;
          for(let ii3=0;ii3<left_arr.length;ii3++){
            let now_item2=left_arr[ii3];
            if(e1.timeRank==(now_item2.from+"-"+now_item2.to)){
              my_now_index=ii3;
              break;
            }
          }
          // console.log("--my_now_index:",my_now_index);
          if((my_now_index+1)<=left_arr.length-1) {
            // console.log("--- 设置下一行产能 my_now_index:",my_now_index);
            let left_item = left_arr[my_now_index ];//这边获取下行坐标有问题
            let count_num1 = null;//目标产能
            for (let key in modelJson) {
              if (e2.model.includes(key)) {
                count_num1 = left_item[modelJson[key]];
                //当前行剩余产能: (下行总时间-下行切线时间)*下行人均产能
                let next_pingjun=count_num1/left_item.duration;
                let next_do_num= (left_item.duration-next_qie_shijian)*next_pingjun;
                // left_item[`${modelJson[key]}2`]= Math.round(next_do_num);
                left_item.next_shengyu_shijian=Math.round(next_do_num/next_pingjun);//剩余时间
                // console.log("---next_left_item.next_shengyu_shijian:",left_item.next_shengyu_shijian)
                break;
              }
            }
          }
        }
      }
    };
  }
  for(let i=p_index;i<local_planDateList.length;i++){
    let p_item= local_planDateList[i];
    let left_arr=p_item.left_arr;
    // console.log("----i:"+i+"--p_item.sun_do:",p_item.sun_do,"---!p_item.sunday:",!p_item.sunday)
    if(p_item.sun_do||!p_item.sunday){
      /**
       * 产线表格
       * 初始化计算 --start
       */
      let child_arr=p_item[`${arr_name}`]||[];
      if(p_index==i){
        if(action_name=="选择"){
          child_arr.splice(rowIndex,1);//那行空的要先去掉
        }else{
          //设置已切线 from
          if(!child_arr[rowIndex].timeRank){
            //去除请选择的那行
            //     child_arr.splice(rowIndex,1);
          }else{
            child_arr[rowIndex].qieXian=1

          }

        }
      }

      if(e2.thisNum<=0){
        // console.log("--e2.thisNum<=0:",e2.thisNum);
        break;//防止出现 中间一半分配完了，还给下一个日期第一个格子还是分配0的情况
      }
      let index_2=rowIndex;
      // 如果是切线的下标不能直接对应
      if(iz_qie_cation){
        //先获取当前行
        let my_now_index=null;
        for(let ii3=0;ii3<left_arr.length;ii3++){
          let now_item2=left_arr[ii3];
          if(e1.timeRank==(now_item2.from+"-"+now_item2.to)){
            my_now_index=ii3;
            break;
          }
        }
        if(my_now_index){
          if(left_arr[my_now_index].countAllOver){
            if(my_now_index+1<=left_arr.length-1){
              my_now_index+=1;
            }
          }
          index_2= my_now_index;
        }
      }

      if(index_2_set.value){
        index_2=0;
      }
      // console.log("---index_2_set:",index_2_set.value);


      for(let i2=index_2;i2<left_arr.length;i2++){
        let count_num=null,count_num_old=null;//剩余目标产能，原目标产能

        let left_item=left_arr[i2];
        for (let key in modelJson) {
          //匹配型号 获取对应的产能
          if(e2.model.includes(key)){
            // 不是切线的逻辑
            if(!iz_qie_cation){
              count_num=left_item[modelJson[key]];
            }else{

            }
            if(left_item[`${modelJson[key]}2`]){
              count_num=left_item[`${modelJson[key]}2`];
            }else{
              count_num=left_item[modelJson[key]];

              // console.log("---left_item[modelJson[key]]",count_num,"---key:",`${modelJson[key]}`)
            }
            //查看有没有剩余时间
            // left_item.shengyu_changneng
            // count_num_old=left_item[modelJson[key]]
          }
        };
        if(!count_num){
          createMessage.error("获取不到目标产能,该型号 不在名单中！");
          dis_click_jiaban.value=false;
          return
        }
        /**
         * 当前行的剩余产能
         */
        let child_item={...e2};
        delete child_item._X_ROW_KEY;
        delete child_item.izNull;
        // if(left_item.next!=null){
        //   console.log("--left_item.next:",left_item.next)
        //   child_item.timeRank=left_item.next.timeRank;
        // }else{
        // }
        child_item.timeRank=`${left_item.from}-${left_item.to}`;

        // console.log("---e2.thisNum:",e2.thisNum,"---count_num:",count_num,"---left_item:",left_item);

        if(count_num>=0){
          //TODO 剩余产能 大于=0的情况
          if(e2.thisNum-count_num>=0){
            // console.log("---count_num:",count_num);
            let num=e2.thisNum-count_num;
            // console.log("---得出结果 num",num)
            e2.thisNum=num;
            child_item.num=count_num;
            child_item.allType=1;//allType 是否能够完全被分配 1 完全 0 有剩余时间可被分配其他 产品

            if(e2.thisNum==0){
              left_item.countAllOver=1;//全部被算完
              //下个时间段还能分配
              if(i2+1<=left_arr.length-1){
                child_item.allType=0
                left_item.next_shengyu_shijian=left_item.duration-formData.value.qieNum;
              }
            }
          }else{
            // debugger
            let num=e2.thisNum;
            // console.log("---最终得出结果 num",num)
            child_item.num=num;
            if(num<=count_num){
              /**
               * 这边还要判断
               * 1 下方还有没有时段，如果有时段
               * 2 如果还有时段 要纳入切线时间,并设置成完全分配
               */
              if(i2+1<=left_arr.length-1){
                //计算剩余产能 ： 产能/总时间 * 剩余时间
                let pingjun=count_num/left_item.duration;//每分钟平均产能
                let biao_zhun=pingjun*(left_item.duration-formData.value.qieNum);
                let shengyu_changneng=biao_zhun-num;//e1.num=270,实际产能240
                let shengyu_shijian=Math.round(shengyu_changneng/pingjun);//当前剩余时间
                //shengyu_shijian 当前剩余时间
                if(shengyu_shijian>0){
                  left_item.now_shengyu_shijian=shengyu_shijian
                }else{
                  left_item.next_shengyu_shijian=Math.abs(shengyu_shijian);//当前时间段的下一个时间段的剩余时间

                }
                //left_item.countAllOver=1;//全部被算完
                child_item.allType=0;//时间段刚好分完 ,但是还是下个时间端,下个时间段 继续加10分钟

              }else {
                child_item.allType=0;

              }

            }else{
              child_item.allType=1;
            }
            e2.thisNum=0;
          }
        }else{
          //TODO 剩余产能是负数的情况 count_num=-30
          if(e2.thisNum+count_num-count_num_old>0){
            // console.log("---count_num:",count_num);
            let num=e2.thisNum+count_num-count_num_old;
            // console.log("---得出结果 num",num)
            e2.thisNum=num;
            child_item.num=count_num_old;

            child_item.allType=1;//allType 是否能够完全被分配 1 完全 0 有剩余时间可被分配其他 产品
          }else{
            // debugger
            let num=e2.thisNum;
            // console.log("---最终得出结果 num",num)
            child_item.num=num;
            if(num<count_num){
              child_item.allType=0;
            }else{
              child_item.allType=1;
            }
            e2.thisNum=0;
          }

        }


        if(child_item.num){
          child_arr.push(child_item);
          // console.log("---child_item:",child_item);
        }else{
          // console.log("---child_item null:",child_item);
        }
        if(e2.izNull){
          delete e2.izNull;
        }
        if(e2.thisNum<=0){

          //还有下个时段 并且 刚刚上个时段已经做完了；如果这个时段  还可以有剩余被分配的时间则 用'切线的逻辑'
          if(i2<left_arr.length-1&&child_item.allType==1){
            // console.log("---izNull1")

            child_arr.push({izNull:1}); //让他可以选择订单标识号
          }else{
            //判断下一个日期还能再分配
            let next_index=null;//获取还有没有 下一个能分配的日期
            let next_count_index=i+1;

            if(next_count_index<= local_planDateList.length-1&&i2==left_arr.length-1){
              for(let ii=next_count_index;ii<local_planDateList.length;ii++) {
                let next_p_item = local_planDateList[ii];
                if(next_p_item.sun_do||!next_p_item.sunday){
                  next_index=ii;
                }
                if(next_index){
                  // TODO 下个日期的第一行设置请选择按钮
                  // next_p_item[`${arr_name}`].push({izNull:1});//让他可以选择订单标识号
                  break;
                }
              }

            };

          }
          //计算不下去了跳出循环
          break;
        }
        //let row_shengyu_num=Math.abs(e2.thisNum-count_num) ;//取绝对值

      }
      if(i==local_planDateList.length-1){
        // console.log("--有没有剩余:",e2.thisNum,"----i:",i)
        p_item[`${arr_name}_shengyu_num`]=e2.thisNum;
      }else{
        //下一个是周日，又没排班的话， 要提示
        let next_p_item=local_planDateList[i+1]
        if(next_p_item.sunday&&!next_p_item.sun_do){
          p_item[`${arr_name}_shengyu_num`]=e2.thisNum;

        }
      }
      p_item[`${arr_name}`]=child_arr;
      // console.log("--p_item:",p_item);

      /**
       * 初始化计算 --end
       */
    }

    if(iz_qie_cation&&rowIndex!=0){
      index_2_set.value=true;
      // rowIndex=0;
    }

    //去除选择项
    if(p_item.no_select_jiaban){
      // let child_arr=p_item[`${arr_name}`]||[];

    }

  }
  /**
   * 计算结束
   */
  /**
   * 统计 尾部合计
   */
  for(let i=p_index;i<local_planDateList.length;i++) {
    let p_item = local_planDateList[i];
    // let left_arr=p_item.left_arr;
    let arr1=p_item.arr1;
    let arr1_total=0,arr2_total=0;
    arr1.forEach((item,index)=>{
      if(item.num){
        arr1_total+=item.num;
      }
    })
    let arr2=p_item.arr2;
    arr2.forEach((item,index)=>{
      if(item.num){
        arr2_total+=item.num;
      }
    })
    p_item.footData.arr1_total=arr1_total;
    p_item.footData.arr2_total=arr2_total;
  }

  planDateList.value=local_planDateList

  index_2_set.value=false;
}



/**
 * 切线
 * @param e1
 */
function orderSuccessFn2(e2){
  const {
    data,
    p_index,
    rowIndex,
    arr_name
  }= qie_xian_obj.value;

  /**
   * 校验型号
   */
  let modelJson =getCountModelJson();
  let pass=false;
  for (let key in modelJson) {
    //匹配型号 获取对应的产能
    if (e2.model.includes(key)) {
      pass=true;
    }
  }
  if(!pass){
    openAlert();
    return false;
  }
  // console.log("---data:",data,"----e2:",e2);

  handleArr(e2,data,p_index,rowIndex,arr_name,"切线")
}

function getCountModelJson(){
  let json={
    "100":"100",
    "200":"200_500",
    "500":"200_500",
    "计步器":"step",
    "K950":"K950"
  }
  return json;
}



function getActions(record,p_index,rowIndex,arr_name) {
  let arr=[];
  if(record.allType==0){
    arr.push({
      label: '切线',
      disabled:record.qieXian==1,
      onClick: handleEdit.bind(null, record,p_index,rowIndex,arr_name),
    })
  }
  return arr;
}

function handleEdit(record: Recordable,p_index,rowIndex,arr_name) {
  qie_xian_obj.value={
    data:record,
    p_index,
    rowIndex,
    arr_name
  }
  qieXianRef.value.openFn();
}


const openAlert = () => {
  VxeUI.modal.confirm({
    id:"myAlert1",
    content: '该产品型号不在目标产能表格中无法进行计算!',
    status: 'error',
    lockView: true,
    mask: false,
    showClose: false,
    showConfirmButton: false
  }).then(type => {
    console.log(`操作类型 ${type}`)
  })
}

const closeAlert = () => {
  VxeUI.modal.close("myAlert1")
}

/**
 * 提交
 */

function  subFn(){
  if(planDateList.value.length==0){
    createMessage.error("请先生成！")
    return;
  }
  let data={
    formData:formData.value,
    planDateList:planDateList.value,
    selectOrderNo:selectOrderNo.value,
  }
  // console.log("---data:",data);
  saveLoading.value=true;
  productionPlanAdd(data).then(res=>{
    if(res.code==200){
      mainId.value=res.data;
    }else{
      createMessage.error(res.message)
    }
  }).finally(()=>{
    saveLoading.value=false;
  });

}

</script>
<style lang="less">
.my-table{
  //width: 40%;
  width: 550px;
  margin-bottom: 5px;
  margin-top: 5px;
}
</style>
